Electronics devices and capabilities have grown extremely common in daily life. Along with personal computers in the home, many individuals carry more than one productivity tool for various and sundry purposes. Most personal productivity electronic devices include some form of non-volatile memory. Cell phones utilize non-volatile memory in order to store and retain user programmed phone numbers and configurations when the power is turned off. PCMCIA cards utilize non-volatile memory to store and retain information even when the card is removed from its slot in the computer. Many other common electronic devices also benefit from the long-term storage capability of non-volatile memory in un-powered assemblies.
Non-volatile memory manufacturers that sell to the electronic equipment manufacturers require testers to exercise and verify the proper operation of the memories that they produce. Due to the volume of non-volatile memories that are manufactured and sold at consistently low prices, it is very important to minimize the time it takes to test a single part. Purchasers of non-volatile memories require memory manufacturers to provide high shipment yields because of the cost savings associated with the practice of incorporating the memory devices into more expensive assemblies with minimal or no testing. Accordingly, the memory testing process must be sufficiently efficient to identify a large percentage of non-conforming parts and preferably all non-conforming parts in a single test process.
As non-volatile memories become larger, denser and more complex, the testers must be able to handle the increased size and complexity without significantly increasing the time it takes to test them. Memory testers frequently run continuously, and test time is considered a major factor in the cost of the final part. As memories evolve and improve, the tester must be able to easily accommodate the changes made to the device. Another issue specific to testing non-volatile memories is that repeated writes to cells of the memories can degrade the overall lifetime performance of the part. Non-volatile memory manufacturers have responded to many of these testing issues by building special test modes into the memory devices. These test modes are not used at all by the purchaser of the memory, but may be accessed by the manufacturer to test all or significant portions of the memories in as little time as possible and as efficiently as possible. Some non-volatile memories are also capable of being repaired during the test process. The tester, therefore, should be able to identify: a need for repair; a location of the repair; the type of repair needed; and, must then be able to perform the appropriate repair. Such a repair process requires a tester that is able to detect and isolate a specific nonconforming portion of the memory. In order to take full advantage of the special test modes as well as the repair functions, it is beneficial for a tester to be able to execute a test program that supports conditional branching based upon an expected response from the device.
From a conceptual perspective, the process of testing memories is an algorithmic process. As an example, typical tests include sequentially incrementing or decrementing memory addresses while writing 0""s and 1""s into the memory cells. It is customary to refer to a collection of 1""s and 0""s being written or read during a memory cycle as a xe2x80x9cvectorxe2x80x9d, while the term xe2x80x9cpatternxe2x80x9d refers to a sequence of vectors. It is conventional for tests to include writing patterns into the memory space such as checkerboards, walking 1""s and butterfly patterns. A test developer can more easily and efficiently generate a program to create these patterns with the aid of algorithmic constructs. A test pattern that is algorithmically coherent is also easier to debug and facilitates the use of logical methods to isolate portions of the pattern that do not perform as expected. A test pattern that is generated algorithmically using instructions and commands that are repeated in programming loops consumes less space in tester memory. Accordingly, it is desirable to have algorithmic test pattern generation capability in a memory tester.
Precise signal edge placement and detection is also a consideration in the effectiveness of a non-volatile memory tester. In order to identify parts that are generally conforming at a median while not conforming within the specified margins, a non-volatile memory tester must be able to precisely place each signal edge relative in time to another signal edge. It is also important to be able to precisely measure at which point in time a signal edge is received. Accordingly, a non-volatile memory tester should have sufficient flexibility and control of the timing and placement of stimuli and responses from the Device Under Test (memory).
Memory testers are said to generate transmit vectors that are applied (stimulus) to the DUT (Device Under Test), and receive vectors that are expected in return (response). The algorithmic logic that generates these vectors can generally do so without troubling itself about how a particular bit in a vector is to get to or from a particular signal pad in the DUT, as the memory tester contains mapping arrangements to route signals to and from the pins that contact the DUT. The collection of the algorithmic pattern generation, threshold setting, signal conditioning and comparison mechanisms, and the probes that connect that stuff to the DUT, is called a test site. In the simple case there is one DUT per test site.
Memory testers have interior test memory that is used to facilitate the test process. This interior test memory may be used for several purposes, among which are storing transmit vectors ahead of time, as opposed to generating them in real time, storing expected receive vectors, and storing a variety of error indications and other information concerning DUT behavior obtained during testing. (There are also housekeeping purposes internal to the operation of the memory tester that use RAM and that may appear to fall within the purview of the phrase xe2x80x9cinterior memory.xe2x80x9d These are private to the internal operation of the tester, tend to not be visible at the algorithmic level, and are comparable to executable instruction stores and to internal control registers. That memory is described as xe2x80x9cinterior control memory,xe2x80x9d and is excluded from what is meant herein by the term xe2x80x9cinterior test memory,xe2x80x9d which we use to describe memory used to store bit patterns directly related to the stimulus of, and response from, the DUT.) It is easy to appreciate that this interior test memory needs to operate at least as fast as the tests being performed; a very common paradigm is for the interior test memory (or some portion thereof) to be addressed by the same address (or some derivative thereof) as is applied to the DUT. What is then stored at that addressed location in interior test memory is something indicative of DUT behavior during a test operation performed on the DUT at that address. Algorithmic considerations within the test program may mean that the sequence of addresses associated with consecutive transmit vectors can be arbitrary. Thus, the interior memory needs to have the dual attributes of high speed and random addressability. SRAM comes to mind immediately as being fast, easy to control and tolerant of totally random addressing. Indeed, conventional memory testers have used SRAM as their interior test memory.
Unfortunately, SRAM is quite expensive, and this has limited the amount of interior test memory with which memory testers have had to work. The result is limits on memory tester functionality that are imposed by a shortage of memory. DRAM is significantly less expensive, but cannot tolerate random addressing and still perform at high speed.
DRAM can replace SRAM as the interior test memory in a memory tester. As briefly described below, the problem of increasing the speed of DRAM operation for use as interior test memory can be solved by increasing the amount of DRAM used, in place of increasing its speed. Numbers of identical Banks of DRAM are treated as Groups. A combination of interleaving signals for different Banks of memory in a Group thereof and multiplexing between those Groups of Banks slows the memory traffic for any one Bank down to a rate that can be handled by the Bank.
At the top level of interior test memory organization there are four Memory Sets, each having its own separate and independent address space and performing requested memory transactions. Two are of SDRAM as described above, and two are of SRAM. Each Memory Set has its own controller to which memory transactions are directed. As to externally visible operational capabilities as memories, all four Memory Sets are essentially identical. They differ only in their size of memory space and how they are internally implemented: The SRAM Memory Sets do not employ multiplexing and interleaving, since they are fast enough to begin with. Despite their independence, Memory Sets of the same type (of SRAM or of DRAM) may be xe2x80x9cstacked,xe2x80x9d which is to say treated a one larger address space.
Thus it is that the interior test memory of the tester is divided into four Memory Sets, two of which are xe2x80x9cinternalxe2x80x9d SRAM""s and two of which are xe2x80x9cexternalxe2x80x9d DRAM""s. To be sure, all this memory is physically inside the memory tester; the terms xe2x80x9cinternalxe2x80x9d and xe2x80x9cexternalxe2x80x9d have more to do with a level of integration. The SRAM""s are integral parts of a VLSI (Very Large Scale Integration) circuit associated with the tester""s central functional circuitry, while the DRAM""s are individual packaged parts mounted adjacent the VLSI stuff. The amount of SRAM is fairly small, (say, around a megabit per Memory Set) while the amount of DRAM is substantial and selectable (say, in the range of 128 to 1024 megabits per Memory Set). The SRAM Memory Sets are always present, and may be used for any suitable purpose, such as storing the expected content of a DUT that is a ROM (Read Only Memory). The DRAM Memory Sets, although actually optional, are typically used for creating a trace for subsequent analysis leading to repair, although there are also other uses. The tester need not, in principle, enforce distinctions between the SRAM and DRAM Memory Sets, as to different purposes for which they may be used. There are some practical distinctions that arise mostly as a matter of size; the SRAM Memory Sets are small, while the DRAM Memory Sets are potentially huge. The person or persons creating the test programming generally make the decisions concerning how the various Memory Sets are to be used. There are, however, a few distinctions where a particular operational feature of the memory tester requires the use of a specific Memory Set. These cases usually arise out of economic or performance considerations that require a dedicated hardware path to a Memory Set. While these mechanisms could be generalized, it is expedient to simply pick a likely one, and let it go at that.
The advent of substantial amounts of interior test memory (in the form of the DRAM Memory Sets) raises the issue of how this additional amount of memory can be used to facilitate the operation of desirable features within the memory tester. In the tester of interest the interior test memory subsystem is extremely flexible, in that despite having a native word width of thirty-two bits, the effective word width can be any power of two (up to 25=32), with a corresponding increase in address space for narrower words. There is an extensive address mapping capability, both for addressing DUT""s and for addressing interior test memory, substantial data classification and address classification mechanisms that facilitate multiple Tag RAM""s and other error analysis tools, all of which are made more practical by having lots of interior test memory. Moreover, these enhancements made possible by more memory do not exist in a vacuum; they are very valuable in the testing of certain types of memory parts.
Despite that recent advances have produced memory parts of truly enormous capacity (512 MB) and wide data paths (thirty-two bits), yesterday""s four, eight and sixteen bit parts are still solidly in commercial service. It is even the case that some high capacity parts have been xe2x80x9cthrottled downxe2x80x9d to a narrow path for address and data, even at the expense of serialization or of supporting multiple cycle segmentation to transport whole data of a wider native word width. There are various reasons for this situation: either small parts are all that is needed, or, the application is such that big parts can have narrow paths (video applications that are always addressed sequentially). Suffice it to say that there are good economic reasons why memory parts with narrow paths are well received in the market. And that means that they have to be tested.
From time to time it may be desirable to check eight bit parts on a memory tester having sixty-four channels per test head. What with supplies and ground, I/O bus, clocks and assorted control lines, there are perhaps from twelve to sixteen channels that will be needed. Suppose it is fourteen. This does not mean that fifty channels will be left unused when the part to be tested is located under the test head.
Note that sixty-four channels is enough to do as many as sixteen channels four times. A combination of four undiced DUT""s on a wafer, or four packaged parts, can be construed as some strange single big part that just happens to look exactly like the union of four little parts. In theory, those four little parts can be tested at the same time, simultaneously, under the same test head. The trouble is that it is awkward and inconvenient. The test program has to be re-written, so that a single-thread-of-control test program emulates a four-threads-of-control test program, where each of those four threads (what is done for an individual DUT) has conditional branching and other result dependent behavior. This would be a very ugly business that might seem to be better served by four independent execution mechanisms with four simple programs whose internal execution paths could independently diverge as needed. But then, how to return to the other extreme, where all sixty-four channels need to be controlled by one program testing an actual single big part? Four little processors do not make a big processor!
The internal architecture of a memory tester can be enhanced to support the testing of multiple DUT""s of the same type at a test site, while requiring only minor modifications to a test program that would ordinarily be used to test a single DUT. The multiple DUT""s are electrically isolated from one another, but are, at least at the outset, given the same stimulus from which the same response is expected. To do this the DUT""s are each associated with collections of channels that are to be used to test their respective DUT""s. The tester can be instructed to replicate the segments of the test vectors needed to test one DUT on the channels for the other DUT""s. This produces patterns of (sequences of) transmit (stimulus) and receive (response) vectors that are xe2x80x9cn-many DUT""s wide,xe2x80x9d as it were. Conditional branching within the test program in response to conditions in the receive vectors (DUT failure) is supported by recognizing several types of error indications and an ability to selectively disable the testing of one or more DUT""s while continuing to test the one or more that are not disabled. The error indications include per channel functional error flags and per DUT functional error flags, as well as per DUT parametric error flags. The per DUT functional error flags are created from an OR""ing of the per channel functional error flags done in accordance with the DUT to channel association. These flags are reported back to the test program, which can then take various appropriate actions that alter program flow to invoke special testing or other actions for the suspect DUT. The error conditions are also detected by pre-programmed mechanisms within the circuitry that applies transmit vectors and evaluates receive vectors. These latter pre-programmed mechanisms produce actions that include, on a per channel basis, the ability to alter the drive and receive formats for the DUT signal of that channel, and the ability to alter a data value associated with the DUT signal of that channel. Also included are ways to remove or limit stimulus to particular DUT""s, as well as ways to make all comparisons for a particular DUT appear to be xe2x80x9cgood,xe2x80x9d regardless of the true facts. These latter mechanisms remove the need for multiple threads of execution in the test program.
The test program is thus empowered to simultaneously test a plurality (up to four in a preferred embodiment) of DUT""s xe2x80x9cin parallelxe2x80x9d as long as no errors are reported. Upon an error the test program can branch to an error investigation routine that exercises only the suspect DUT by temporarily disabling the good DUT""s while continuing to exercise the bad DUT. If the bad DUT is defective beyond repair, or is unsafe to leave powered up, it can be disabled, the other DUT""s re-enabled and regular testing resumed. In this way, a single thread of execution (that would exist in essentially this same form for testing a single DUT) can be selectively switched between (executed on behalf of) the different DUT""s on an as needed basis, driven by which one(s) fail(s). During these selectively switched intervals simultaneous testing of all DUT""s is suspended in favor of a digression that tests a particular DUT of interest. To be sure, this switching and jumping to execute digressions is also programmatically defined to occur in response to contingent events discovered while testing. Part of this programmatic definition are easily performed modifications to the single threaded test program (which remains single threaded) and part of it is pre-configuration of various hardware assist mechanisms.
Certain types of memory technology, such as FLASH memory, have particular properties that affect the way they are used and also the way they can be tested. With FLASH memory, for example, it is typically the case that an erase function is used to get the device (or a portion thereof, called a block) to store all 1""s, and to write a 0 it is xe2x80x9cprogrammedxe2x80x9d by a repeated write operation performed at the address that is to store the 0. Whereas an erase is a mass operation affecting a large number of addresses (either the entire device or the block containing a supplied address), programming a 0 at an addressed location involves repeating a write operation until sufficient charge transfer has occurred in the addressed memory cell. For modern FLASH memory, the device itself internally reads back the cell contents during automated internal writes repeatedly performed until the programming has occurred. For example, an eight-bit device would internally check the eight bits at that address, and programming would continue internally until each of the however many 0""s there are among those eight bits has been successfully programmed. Some cells in the memory may program more readily than others, and it may take several hundred write cycles to program a 0.
A modern FLASH device accepts such operations in the form of commands, and reports the eventual success or failure of their outcome on output lines driven by a status register. So, for example, an address and some data can be supplied to the device, and a program line or command exerted. The status register goes to, say, all 0""s to indicate xe2x80x9cI""m busy,xe2x80x9d and in due course changes to all 1""s to indicate xe2x80x9cI""m finished and it worked.xe2x80x9d Any other bit patterns in this sequence of operations would be an error code descriptive of some sort of trouble.
Re-programming an address to have a 1 after it has been previously programmed to contain a 0 is an allowed operation, but is one that cannot be performed, owing to the way FLASH devices are constructed. If there is a need to do that the entire device (or the block containing that address) must be erased, and programming begun over again. Nevertheless, it has become a standard mode of operation for FLASH devices to accept commands to program 1""s, and ignore them while reporting immediate success.
Thus, from afar the test paradigm for a FLASH part looks like a three part procedure. First the part is erased. Second, the part is programmed, and then (third) it is exercised. To be sure, getting the part successfully programmed is part of what is properly considered testing of the device. Once programmed, however, the test engineer may want to exercise it by varying supply voltages, checking timing relationships, and ensuring that addressing sequences and patterns in the stored data do not adversely affect operation. The complete battery of tests for a FLASH part may include several such three part procedures, each with a different collection of programmed data, and perhaps with different exercise activities. Generally speaking, exercising the part is not where test time is spent; it is spent erasing and programming the part.
The internal organization of some memories, including FLASH parts, involves the notion of columns. There are many addresses associated with a column, and if there should be a failure in the column decoding, many addresses will be affected. Even in the case where there is simply a bad cell in a column (i.e., a single bit failure at a single address), we would still have to say that the column is defective. Either way, at some point in a programming phase there will be an address that does not program successfully. At that point we would say the column containing that address is bad.
The discovery that a column in a FLASH part is defective can occur during programming, or it can be discovered while exercising. The latter case is difficult to characterize ahead of time, and since it likely won""t be reported as status information by the device itself, it will need to be detected by suitable algorithmic mechanisms in the test program.
Whether or not a bad column can be repaired is another issue, and is one which will probably be decided at a different time. (A decision to attempt a repair might best be delayed until after a preliminary testing reveals the scope of any repairable failures: in any DUT there is only a fixed number of substitute circuits that can be switched in by xe2x80x9czappingxe2x80x9d fusible links within the device.) For the present we could save some time on the tester if, for the balance of the testing for that part, we could arrange to not spend any more time trying to program other addresses in that column.
Whether the bad column is discovered while performing multi-DUT per test head testing or while performing single DUT per test head operations, it would thus be desirable (and especially so in the multi-DUT case) to take note of that fact with the intention of dealing with it later (probably by an attempted repair). In the meantime, however, it is desirable to continue the testing (for the benefit of the other columns), while suppressing attempts to perform any further programming on the bad column. Unless such a mechanism is in place, extra time will be wasted trying to program addresses that are in the bad column. While it is reasonable to ask that a test program decide during exercising if a column is defective (in a way that is what the test is for), it is undesirable to burden that test program (whether during programming or exercising) with the further task of altering subsequent program flow to avoid further programming of other addresses within a column that is known to be bad. This is especially so in a multi-DUT situation.
What to do?
A test program generates transmit vectors (stimuli) and receive vectors (expected responses). The transmit vectors are applied to the DUT, while the receive vectors are treated as comparison values used to decide if a response from the DUT is as expected. While programming a FLASH part the test program uses TAG RAM techniques to maintain a BAD COLUMN table in one of the memory sets. This BAD COLUMN table is addressed by the same address that is applied to the DUT. If an OMIT BAD COLUMN mode is in effect, entries in this table are, by automatic action of the memory tester hardware, obtained and used to supply a replacement programming data value of all 1""s (or some other pattern) that will produce an immediate and automatic indication of successful programming from the DUT. This prevents spending extra time programming a column that has been determined to be bad, without requiring an alteration in the internal mechanism of the test program. The discovery of bad columns and their recordation in the BAD COLUMN table can be performed during an initial programming phase of the test program, or it can be performed on an xe2x80x9cas-discoveredxe2x80x9d basis during the course of exercising a programmed FLASH DUT.
These features may be combined with automatic reading of a special BAD BLOCK table created in interior test memory to facilitate the testing of memory parts that have an internal block structure, by automatically disabling, and removing from further influence on the test program, actions related to a bad block. That bad block may or may not be in a DUT that is being tested in a multi-DUT fashion.